// import { Config } from "../../config/Config";
// import { RedisConfig } from "../../config/RedisConfig";
// import { Logger } from "./Logger";
// import { ZoneModel } from "../../model/ZoneModel";

// const redis = require('redis')

// export class RedisClient {

//     private static onlyId: number = 0;

//     private id: number;
//     private redisClient;
//     private isConnected: boolean;
//     private nowSelectingDatabase: string;
//     private nowSelectDatabase: string;
//     private isGettingData: boolean;
//     private isGettingKeys: boolean;
//     private config: RedisConfig;

//     public init(config: RedisConfig) {
//         this.id = RedisClient.onlyId;
//         this.config = config;
//         RedisClient.onlyId++;
//         if (!this.isConnected) {
//             Logger.log("RedisClient.init", this.id, this.config);
//             let RDS_OPTS = { auth_pass: Config.getRedisPass() }
//             this.redisClient = redis.createClient(Config.getRedisPort(), Config.getRedisUrl(), RDS_OPTS)
//             this.redisClient.on('ready', (res) => {
//                 Logger.log('RedisClient.ready', this.id, this.config);
//             });
//             this.redisClient.on('end', (err) => {
//                 Logger.log('RedisClient.end', this.id, this.config, err);
//             });
//             this.redisClient.on("reconnecting", (err, aa) => {
//                 Logger.log("RedisClient.reconnecting", err, aa)
//             })
//             this.redisClient.on('error', (err) => {
//                 Logger.error("redis connect error==", this.id, this.config, err)
//                 this.isConnected = false;
//             })
//             this.redisClient.on("warning", (err) => {
//                 Logger.warn("RedisClient.warning", err)
//             })

//             // this.redisClient.monitor((err, res) => {
//             //     if (err) {
//             //         Logger.error("redis Entering monitoring mode. error", this.databaseIndex, err);
//             //     } else {
//             //         Logger.log("redis Entering monitoring mode.", this.databaseIndex, res);
//             //     }
//             // });
//             // this.redisClient.on("monitor", (time, args, rawReply) => {
//             //     // Logger.log("redis data change=1==", time); // 1458910076.446514:['set', 'foo', 'bar']
//             //     // Logger.log("redis data change==2=", args); // 1458910076.446514:['set', 'foo', 'bar']
//             //     // Logger.log("redis data change=3==", rawReply); // 1458910076.446514:['set', 'foo', 'bar']
//             //     // "1596442771.252363 [0 113.111.247.226:52493] "select" "15""
//             //     let rawArr: Array<string> = rawReply.split(" ");
//             //     let nowDatabaseIndex: number = parseInt(rawArr[1].substring(1));
//             //     let cmd = String(args[0]).toLowerCase();
//             //     // Logger.log("redis cmd======rawArr=", cmd, rawArr, rawArr[1][1], nowDatabaseIndex)
//             //     // Logger.log("redis cmd===",cmd, rawArr[1], nowDatabaseIndex)
//             //     // if (cmd == "set" || cmd == "del" || cmd == "HMSET") {
//             //     if (cmd == "set" || cmd == "del" || cmd == "hmset") {

//             //     }
//             // });
//             this.redisClient.on("connect", (param) => {
//                 Logger.log("redis connect suc==", this.id, this.config);
//                 this.isConnected = true;
//                 this.selectDatabase(this.config.redis_db + "", () => {
//                     Logger.log("redis selectDatabase suc==", this.id, this.config);
//                 });
//             });
//         }
//     }

//     public selectDatabase(databaseName: string = "1", callback: Function) {
//         if (this.isGettingData || this.isGettingKeys) { //正在获取数据获取获取Keys不能切换数据库
//             callback && callback(false);
//         }
//         else if (this.nowSelectingDatabase) { //正在切换数据库
//             callback && callback(false);
//         }
//         else if (this.nowSelectDatabase == databaseName) {
//             callback && callback(true);
//         } else {
//             this.nowSelectingDatabase = databaseName;
//             Logger.log("selectDatabase==start", databaseName);
//             this.redisClient.select(databaseName, (err) => {
//                 this.nowSelectingDatabase = null;
//                 this.nowSelectDatabase = databaseName;
//                 if (err) {
//                     Logger.error('RedisClient selectDatabase error', err);
//                 } else {
//                     Logger.log("selectDatabase==suc", databaseName);
//                     callback && callback(true);
//                 }
//             })
//         }
//     }

//     public getAllKeys(callback: Function) {
//         this.redisClient.keys("*", (err, keyList) => {
//             if (err) {
//                 Logger.error("getAllKeys error", this.config, err)
//             } else {
//                 this.isGettingKeys = false;
//                 callback && callback(true, keyList);
//             }
//         });
//     }

//     public getKeysPromise(keys: string): Promise<Array<string>> {
//         return new Promise((resolve, reject) => {
//             this.getKeys(keys, (isOk: boolean, keyList) => {
//                 resolve(keyList)
//             })
//         })
//     }

//     public getKeys(keys: string, callback: Function) {
//         this.redisClient.keys(keys, (err, keyList) => {
//             this.isGettingKeys = false;
//             if (err) {
//                 Logger.error("RedisClient getKeys error==", keys, err);
//             } else {
//                 callback && callback(true, keyList);
//             }
//         });
//         // }
//     }

//     public getValuePromise(key: string = "100001"): Promise<string> {
//         return new Promise((resolve, reject) => {
//             this.getValue(key, (obj) => {
//                 resolve(obj)
//             })
//         })
//     }

//     public getValue(key: string = "100001", callback: Function = null) {
//         this.isGettingData = true;
//         this.redisClient.get(key, (err, data) => {
//             this.isGettingData = false;
//             if (err) {
//                 Logger.error("RedisClient getValue error==", key, err);
//             } else {
//                 // Logger.log("RedisClient getValue===", key, data);
//                 callback && callback(data);
//             }
//         })
//     }

//     public setValue(key: string, value: string, callback: Function = null) {
//         this.redisClient.set(key, value, (err, data) => {
//             if (err) {
//                 Logger.error("RedisClient setValue error==", key, err);
//             } else {
//                 // Logger.log("RedisClient setValue===", key, value, data);
//                 callback && callback(true, data);
//             }
//         })
//     }

//     public zrange(key: string, callback: Function) {
//         this.redisClient.zrange(key, 0, -1, (err, res) => {
//             if (err != null) {
//                 Logger.log("==zrange== error is: ", err);
//             } else {
//                 Logger.log("zrange===data==", res);
//                 callback && callback(res)
//             }
//         });
//     }


//     //设置过期时间
//     public expire(key: string, second: number) {
//         this.redisClient.expire(key, second);//60秒自动过期
//     }

//     public hlenPromise(key: string): Promise<number> {
//         return new Promise((resolve, reject) => {
//             this.hlen(key, (obj) => {
//                 resolve(obj);
//             })
//         })
//     }

//     public hlen(key: string, callback: Function) {
//         this.redisClient.hlen(key, (err, obj) => {
//             if (err) {
//                 Logger.error("hlen error===", key)
//             } else {
//                 callback && callback(obj);
//             }
//         });
//     }

//     public hsetPromise(key1: string, key2: string, value: string): Promise<any> {
//         return new Promise((resolve, reject) => {
//             this.hset(key1, key2, value, (obj) => {
//                 resolve(obj);
//             })
//         })
//     }

//     public hset(key1: string, key2: string, value: string, callback: Function) {
//         this.redisClient.hset(key1, key2, value, (err, obj) => {
//             if (err) {
//                 Logger.error("hset error===", key1, key2)
//             } else {
//                 callback && callback(obj);
//             }
//         });
//     }

//     public hgetPromise(key1: string, key2: string): Promise<any> {
//         return new Promise((resolve, reject) => {
//             this.hget(key1, key2, (obj) => {
//                 resolve(obj)
//             })
//         })
//     }

//     public hget(key: string, key2: string, callback: Function) {
//         this.redisClient.hget(key, key2, (err, obj) => {
//             if (err) {
//                 Logger.error("hget error===", key, key2, err)
//                 callback && callback(obj, err);
//             } else {
//                 // Logger.log("hget obj=====", obj)
//                 callback && callback(obj);
//             }
//         });
//     }

//     public hgetallPromise(key: string): Promise<object> {
//         return new Promise((resolve, reject) => {
//             this.hgetall(key, (data) => {
//                 resolve(data);
//             })
//         })
//     }

//     public hgetall(key: string, callback: Function) {
//         this.redisClient.hgetall(key, (err, obj) => {
//             if (err) {
//                 Logger.error("hgetall error====", err)
//             } else {
//                 Logger.log("hgetall obj=====", obj)
//                 callback && callback(obj);
//             }
//         });
//     }

//     public testZset() {
//         //按照 Score1,Key1,Score2,Key2,Score3,Key3方式初始化的
//         var vals = [13, 1, 12, 2, 14, 3, 20, 4]
//         // Logger.log("testZset=== 111=", vals)
//         // this.redisClient.zadd('mysort', vals, (err, res) => {
//         //     if (err != null) {
//         //         Logger.log("testZset=== zadd=error", err)
//         //     } else {
//         //         // Logger.log(res);
//         //         Logger.log("testZset=== zadd=11111111", res)
//         //     }
//         // });

//         // // //无穷大和无穷小的分数区间内，key排名情况
//         this.redisClient.zrange('mysort', 0, -1, (err, res) => {
//             if (err != null) {
//                 Logger.log("==zrange== error is: ", err);
//             } else {
//                 Logger.log("zrange===data==", res);
//             }
//         });

//         //无穷大和无穷小的分数区间内，排名总数
//         // this.redisClient.zcount('mysort', -Infinity, Infinity, (err, res) => {
//         //     if (err != null) {
//         //         Logger.log("==zcount== error is: ", err);
//         //     } else {
//         //         Logger.log("zcount=====", res);
//         //     }
//         // });

//         // //无穷大和无穷小的分数区间内，从大到小的排序
//         // let args1 = ['mysort', '+inf', '-inf'];
//         // this.redisClient.zrevrangebyscore(args1,  (err, res)=> {
//         //     if (err != null) {
//         //         Logger.log("==zrevrangebyscore== error is: ", err);
//         //     } else {
//         //         Logger.log("zrevrangebyscore===",res);
//         //     }
//         // });

//         //指定分数区间，指定查询数量，偏移指定位数后的排名
//         // let max = 3, min = 1, offset = 0, count = 3;
//         // var max = 25, min = 1, offset = 0, count = 4;
//         // let args2 = ['mysort', max, min, 'WITHSCORES', 'LIMIT', offset, count];
//         // this.redisClient.zrevrangebyscore(args2,  (err, res) =>{
//         //     if (err != null) {
//         //         Logger.log("==zrevrangebyscore== error is: ", err);
//         //     } else {
//         //         Logger.log("zrevrangebyscore===",res);
//         //     }
//         // });

//         //根据key去对应排名，从大到小，排名从0开始所以+1
//         // let args3 = ['mysort', 4]
//         // let args3 = ['mysort', 3]
//         // this.redisClient.zrevrank(args3, (err, res) => {
//         //     if (err != null) {
//         //         Logger.log("==zrevrank== error is: ", err);
//         //     } else {
//         //         Logger.log("zrevrank===", res);
//         //     }
//         // });

//     }
// }